import { BASEURL } from '@/utils/const'
import { getUserPermission } from '@/utils/token'
const methods = {};
/**
 * 格式化文件大小
 * @param {number} bytes - 文件大小（单位：字节）
 * @param {number} [decimals=2] - 保留的小数位数（默认2位）
 * @returns {string} 格式化后的文件大小（如 "1.46 MB"）
 */
methods.formatFileSize = (bytes, decimals = 2) => {
  if (bytes === 0) return '0 Bytes';

  const k = 1024;
  const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB'];
  const i = Math.floor(Math.log(bytes) / Math.log(k)); // 计算单位索引

  // 处理小数位，避免返回类似 "1.00 KB" 的情况
  const formattedSize = parseFloat((bytes / Math.pow(k, i)).toFixed(decimals));

  return `${formattedSize} ${sizes[i]}`;
};


/**
 * 压缩图片并返回可直接用于显示的URL
 * @param {File} file - 原始图片文件
 * @param {Object} options - 压缩选项
 * @param {number} [options.quality=0.7] - 压缩质量(0.1-1)
 * @param {number} [options.resizeRatio=1] - 尺寸调整比例(0.1-1)
 * @param {string} [options.format] - 输出格式(image/jpeg, image/png等)
 * @param {'blob'|'base64'} [options.outputType='blob'] - 输出类型
 * @param {boolean} [options.revokeAfter=30000] - 是否在指定时间后释放Blob URL(仅对outputType='blob'有效)
 * @returns {Promise<string>} - 压缩后的URL
 */
methods.compressImage = (file, options = {}) => {
  // 检查是否为有效文件
  if (!file || !file.type.match('image.*')) {
    throw new Error('请提供有效的图片文件');
  }

  // 设置默认选项
  const {
    quality = 0.8,
    width = null,       // 新增：目标宽度
    height = null,      // 新增：目标高度
    keepAspectRatio = true, // 新增：是否保持宽高比
    format = file.type.includes('png') ? 'image/jpeg' : file.type,
    outputType = 'blob',
    revokeAfter = 300000
  } = options;

  return new Promise((resolve, reject) => {
    // 读取文件为DataURL
    const reader = new FileReader();
    reader.onload = function(e) {
      const img = new Image();
      img.onload = function() {
        // 创建画布
        const canvas = document.createElement('canvas');
        const ctx = canvas.getContext('2d');

        // 计算调整后的尺寸
        let newWidth = img.width;
        let newHeight = img.height;

        // 根据宽高设置计算新尺寸
        if (width !== null || height !== null) {
          if (width !== null && height !== null) {
            // 同时设置了宽度和高度
            if (keepAspectRatio) {
              // 保持宽高比，计算最大可能尺寸
              const widthRatio = width / img.width;
              const heightRatio = height / img.height;
              const ratio = Math.min(widthRatio, heightRatio);
              newWidth = img.width * ratio;
              newHeight = img.height * ratio;
            } else {
              // 不保持宽高比，直接使用设置值
              newWidth = width;
              newHeight = height;
            }
          } else if (width !== null) {
            // 只设置了宽度，高度自适应
            newWidth = width;
            newHeight = img.height * (width / img.width);
          } else if (height !== null) {
            // 只设置了高度，宽度自适应
            newHeight = height;
            newWidth = img.width * (height / img.height);
          }
        }

        // 设置画布尺寸
        canvas.width = newWidth;
        canvas.height = newHeight;

        // 绘制图像到画布
        ctx.drawImage(img, 0, 0, newWidth, newHeight);

        // 根据outputType决定返回格式
        if (outputType === 'base64') {
          // 返回Base64格式
          const base64 = canvas.toDataURL(format, quality);
          resolve(base64);
        } else {
          // 返回Blob URL格式
          canvas.toBlob(blob => {
            if (!blob) {
              reject(new Error('图片转换失败'));
              return;
            }

            const url = URL.createObjectURL(blob);

            // 如果设置了revokeAfter，则在指定时间后释放URL
            if (revokeAfter > 0) {
              setTimeout(() => URL.revokeObjectURL(url), revokeAfter);
            }

            resolve(url);
          }, format, quality);
        }
      };

      img.onerror = () => reject(new Error('图片加载失败'));
      img.src = e.target.result;
    };

    reader.onerror = () => reject(new Error('文件读取失败'));
    reader.readAsDataURL(file);
  });
}

methods.compressImageFile = (file, options = {}) => {
  // 检查是否为有效文件
  if (!file || !file.type.match('image.*')) {
    throw new Error('请提供有效的图片文件');
  }

// 设置默认选项
  const {
    quality = 0.8,
    width = null,       // 新增：目标宽度
    height = null,      // 新增：目标高度
    keepAspectRatio = true, // 新增：是否保持宽高比
    format = file.type.includes('png') ? 'image/jpeg' : file.type,
    fileName = file.name.replace(/\.[^\.]+$/, format === 'image/jpeg' ? '.jpg' : '.png'), // 新增：输出文件名
    revokeAfter = 300000
  } = options;

  return new Promise((resolve, reject) => {
    // 读取文件为DataURL
    const reader = new FileReader();
    reader.onload = function(e) {
      const img = new Image();
      img.onload = function() {
        // 创建画布
        const canvas = document.createElement('canvas');
        const ctx = canvas.getContext('2d');

        // 计算调整后的尺寸
        let newWidth = img.width;
        let newHeight = img.height;

        // 根据宽高设置计算新尺寸
        if (width !== null || height !== null) {
          if (width !== null && height !== null) {
            // 同时设置了宽度和高度
            if (keepAspectRatio) {
              // 保持宽高比，计算最大可能尺寸
              const widthRatio = width / img.width;
              const heightRatio = height / img.height;
              const ratio = Math.min(widthRatio, heightRatio);
              newWidth = img.width * ratio;
              newHeight = img.height * ratio;
            } else {
              // 不保持宽高比，直接使用设置值
              newWidth = width;
              newHeight = height;
            }
          } else if (width !== null) {
            // 只设置了宽度，高度自适应
            newWidth = width;
            newHeight = img.height * (width / img.width);
          } else if (height !== null) {
            // 只设置了高度，宽度自适应
            newHeight = height;
            newWidth = img.width * (height / img.height);
          }
        }

        // 设置画布尺寸
        canvas.width = newWidth;
        canvas.height = newHeight;

        // 绘制图像到画布
        ctx.drawImage(img, 0, 0, newWidth, newHeight);

        // 返回File对象
        canvas.toBlob(blob => {
          if (!blob) {
            reject(new Error('图片转换失败'));
            return;
          }

          // 创建可上传的File对象
          const outputFile = new File([blob], fileName, {
            type: format,
            lastModified: Date.now()
          });

          resolve(outputFile);
        }, format, quality);
      };

      img.onerror = () => reject(new Error('图片加载失败'));
      img.src = e.target.result;
    };

    reader.onerror = () => reject(new Error('文件读取失败'));
    reader.readAsDataURL(file);
  });
}


methods.getSplitData = (str = '', cut = ',') => {
  if (!str) return false
  if (str.includes(cut)) {
    return str.split(cut);
  } else {
    return [str];
  }
};

methods.buildTree = (data, labelField = 'title', valueField = 'id', id = '', idKey = '') => {
  const map = {};
  const tree = [];

  // 将每个节点存储到 map 中，以便快速查找
  data.forEach((item) => {
    // 将每个节点存储到 map 中
    data.forEach((item) => {
      map[item[valueField]] = {
        ...item,
        label: item[labelField] || null, // 允许为空
        value: item[valueField] || null, // 允许为空
        children: [],
      };
    });
  });

  // 构建树形结构
  data.forEach((item) => {
    if (id && item[idKey] === id) {
    } else {
      const node = map[item.id];
      if (item.parentId === '0') {
        // 如果是根节点，添加到树中
        tree.push(node);
      } else if (map[item.parentId]) {
        // 如果有父节点，则将当前节点添加到父节点的 children 中
        map[item.parentId].children.push(node);
      }
    }
  });

  // 去掉没有下级的 children 属性
  function removeEmptyChildren(nodes) {
    nodes.forEach((node) => {
      if (node.children.length === 0) {
        delete node.children; // 删除空的 children 属性
      } else {
        removeEmptyChildren(node.children); // 递归处理子节点
      }
    });
  }

  removeEmptyChildren(tree);
  return tree;
};

// 深度克隆
methods.deepClone = (obj) => {
  // 处理基本类型和 null
  if (obj === null || typeof obj !== 'object') {
    return obj;
  }

  // 处理数组
  if (Array.isArray(obj)) {
    return obj.map(item => methods.deepClone(item));
  }

  // 处理对象
  const clonedObj = {};
  for (const key in obj) {
    if (obj.hasOwnProperty(key)) {
      clonedObj[key] = methods.deepClone(obj[key]);
    }
  }

  // 处理函数
  if (typeof obj === 'function') {
    return obj.bind(clonedObj);
  }

  return clonedObj;
}

const getFileFormat = (url) => {
  try {
    // 创建一个 URL 对象，以便安全地解析
    const urlObj = new URL(url);

    // 获取路径部分（如：/sy-design/file/69f7e8cfe3534510946219747ee9699c.jpg）
    const pathname = urlObj.pathname;

    // 获取最后一个 . 出现的位置
    const lastDotIndex = pathname.lastIndexOf('.');

    // 如果存在 . 且不在开头或末尾
    if (lastDotIndex > 0 && lastDotIndex < pathname.length - 1) {
      return pathname.slice(lastDotIndex + 1).toLowerCase();
    } else {
      return null; // 没有找到有效扩展名
    }
  } catch (e) {
    console.error("Invalid URL");
    return null;
  }
}
methods.getFileFormat = getFileFormat

// methods.createLinkAndDownload = async (imageUrl, filename) => {
//   return new Promise((resolve) => {
//     fetch(BASEURL + '/common/downLoad', {
//       method: 'GET',
//       headers: {
//         'X-Image-Url': imageUrl // 将图片URL放在header中
//       }
//     })
//     .then(response => {
//       if (!response.ok) {
//         throw new Error('网络响应失败');
//       }
//       return response.blob(); // 获取blob流，适合下载文件或图片
//     })
//     .then(blob => {
//       const url = window.URL.createObjectURL(new Blob([blob]));
//       const link = document.createElement('a');
//       link.href = url;
//       link.setAttribute('download', filename + '.' + getFileFormat(imageUrl)); // 设置下载的文件名
//       document.body.appendChild(link);
//       link.click();
//       link.parentNode.removeChild(link); // 下载完成后移除元素
//       console.log('开始下载')
//       resolve(1)
//     })
//     .catch(error => {
//       console.error('请求失败:', error)
//       resolve(1)
//     });
//   })
// };


methods.createLinkAndDownload = async (imageUrl, filename) => {
  console.log('下载路径', imageUrl)
    const a = document.createElement('a');
    a.href = imageUrl;
    a.click();
}


/**
 * 从URL中提取文件名（包括扩展名）
 * @param {string} url - 资源的URL
 * @returns {string}
 */
function getFileNameFromURL(url) {
  // 使用正则表达式排除查询字符串，以确保只获取文件名和扩展名
  return decodeURIComponent(url.split('/').pop().split('?')[0]) || 'download';
}


methods.authorization = (key) => {
  let userPermission = getUserPermission()
  return !!userPermission[key]
}


// methods.isCompressedFile = (url) => {
//     // 常见的压缩包文件扩展名集合（全小写）
//     const compressedExtensions = new Set([
//         'zip', 'rar', '7z', 'gz', 'tar', 'bz2', 
//         'xz', 'iso', 'cab', 'arj', 'lzh', 'lzma',
//         'rz', 'tar.gz', 'tar.bz2', 'tgz', 'tbz'
//     ]);

//     try {
//         // 解码URL并提取文件名部分（处理可能的编码字符）
//         const decodedUrl = url;
//         // 提取URL中最后一个斜杠后的部分（文件名+可能的查询参数）
//         const fileNameWithParams = decodedUrl.split('/').pop();
//         // 移除查询参数和哈希部分（如 ?id=1 或 #top）
//         const fileName = fileNameWithParams.split(/[?#]/)[0];
//         console.log(decodedUrl)
//         // 如果没有文件名，直接返回false
//         if (!fileName) return false;

//         // 提取文件扩展名（处理多扩展名情况，如 .tar.gz）
//         const nameParts = fileName.split('.');
//         // 单个部分的文件名没有扩展名
//         if (nameParts.length < 2) return false;

//         // 检查可能的多部分扩展名（从最长可能的开始检查）
//         for (let i = 2; i <= nameParts.length; i++) {
//             const ext = nameParts.slice(-i).join('.').toLowerCase();
//             if (compressedExtensions.has(ext.split('.')[1])) {
//                 return true;
//             }
//         }

//         // 未匹配到任何压缩包扩展名
//         return false;
//     } catch (error) {
//         console.error('判断文件类型时出错:', error);
//         return false;
//     }
// }



methods.isCompressedFile = (url) => {
    // 常见的压缩包文件扩展名集合（全小写）
    const compressedExtensions = new Set([
        'zip', 'rar', '7z', 'gz', 'tar', 'bz2', 
        'xz', 'iso', 'cab', 'arj', 'lzh', 'lzma',
        'rz', 'tar.gz', 'tar.bz2', 'tgz', 'tbz'
    ]);

    try {
        // 解码URL并提取文件名部分（处理可能的编码字符）
        const decodedUrl = url;
        // 提取URL中最后一个斜杠后的部分（文件名+可能的查询参数）
        const fileNameWithParams = decodedUrl.split('?')[0].split('.')[decodedUrl.split('?')[0].split('.').length - 1]
        // 移除查询参数和哈希部分（如 ?id=1 或 #top）
        const fileName = fileNameWithParams;

        // 如果没有文件名，直接返回false
        if (!fileName) return false;
        if (compressedExtensions.has(fileName)) {
            return true;
        }

        // 未匹配到任何压缩包扩展名
        return false;
    } catch (error) {
        console.error('判断文件类型时出错:', error);
        return false;
    }
}




export default methods;


